#ifndef IMAGECOLORADJUSTER_H
#define IMAGECOLORADJUSTER_H

#include <QImage>
#include <QColor>
#include <QDebug>
/// 调整图片的色温，色调 饱和度， 亮度功能的类

// // 色彩调整类
// class ImageColorAdjuster {
// public:
//     // 调整色温（0为标准色温，对应6500K；范围[-50,50]，负值偏暖，正值偏冷）
//     static QImage adjustTemperature(const QImage& image, int offset) {
//         // 限制调整范围在[-50, 50]
//         offset = qBound(-50, offset, 50);

//         QImage result = image.copy();

//         // 色温偏移与开尔文的映射：
//         // 0 → 6500K（标准）
//         // -50 → 2000K（最暖）
//         // 50 → 12000K（最冷）
//         // 计算实际对应的开尔文温度
//         int temperature = 6500 + (offset * 110);  // 线性映射：每偏移1对应110K变化

//         // 色温到RGB的转换表（核心数据不变，基于开尔文温度）
//         static const struct {
//             int temperature;  // 开尔文温度
//             double r, g, b;   // RGB通道缩放系数
//         } tempTable[] = {
//             { 2000, 1.000, 0.320, 0.000 },   // 最暖（对应offset=-50）
//             { 3000, 1.000, 0.560, 0.150 },
//             { 4000, 1.000, 0.720, 0.390 },
//             { 5000, 1.000, 0.830, 0.600 },
//             { 6000, 1.000, 0.910, 0.790 },
//             { 6500, 1.000, 1.000, 1.000 },   // 标准色温（offset=0）
//             { 7000, 1.000, 0.960, 0.920 },
//             { 8000, 0.940, 0.960, 1.000 },
//             { 9000, 0.880, 0.920, 1.000 },
//             { 10000, 0.830, 0.890, 1.000 },
//             { 11000, 0.790, 0.860, 1.000 },
//             { 12000, 0.760, 0.840, 1.000 }   // 最冷（对应offset=50）
//         };

//         // 找到最接近的色温区间，计算RGB缩放系数
//         double rScale = 1.0, gScale = 1.0, bScale = 1.0;
//         int tableSize = sizeof(tempTable) / sizeof(tempTable[0]);

//         if (temperature <= tempTable[0].temperature) {
//             // 低于最低温度，使用最暖参数
//             rScale = tempTable[0].r;
//             gScale = tempTable[0].g;
//             bScale = tempTable[0].b;
//         } else if (temperature >= tempTable[tableSize-1].temperature) {
//             // 高于最高温度，使用最冷参数
//             rScale = tempTable[tableSize-1].r;
//             gScale = tempTable[tableSize-1].g;
//             bScale = tempTable[tableSize-1].b;
//         } else {
//             // 线性插值计算中间值
//             for (int i = 0; i < tableSize - 1; i++) {
//                 if (temperature >= tempTable[i].temperature && temperature < tempTable[i+1].temperature) {
//                     double ratio = (double)(temperature - tempTable[i].temperature) /
//                                    (tempTable[i+1].temperature - tempTable[i].temperature);
//                     rScale = tempTable[i].r + ratio * (tempTable[i+1].r - tempTable[i].r);
//                     gScale = tempTable[i].g + ratio * (tempTable[i+1].g - tempTable[i].g);
//                     bScale = tempTable[i].b + ratio * (tempTable[i+1].b - tempTable[i].b);
//                     break;
//                 }
//             }
//         }

//         // 应用色温调整到每个像素
//         for (int y = 0; y < result.height(); y++) {
//             QRgb* row = (QRgb*)result.scanLine(y);  // 直接操作像素数据，效率更高
//             for (int x = 0; x < result.width(); x++) {
//                 QRgb pixel = row[x];
//                 // 按缩放系数调整RGB值，确保在[0,255]范围内
//                 int r = qBound(0, (int)(qRed(pixel) * rScale), 255);
//                 int g = qBound(0, (int)(qGreen(pixel) * gScale), 255);
//                 int b = qBound(0, (int)(qBlue(pixel) * bScale), 255);
//                 row[x] = qRgb(r, g, b);
//             }
//         }

//         return result;
//     }

//     // 调整色调（范围：-180 到 180）
//     static QImage adjustHue(const QImage& image, int hueDelta) {
//         QImage result = image.copy();

//         for (int y = 0; y < result.height(); y++) {
//             for (int x = 0; x < result.width(); x++) {
//                 QColor color = result.pixelColor(x, y);
//                 int h, s, v;
//                 color.getHsv(&h, &s, &v);

//                 // 调整色调
//                 if (h >= 0) { // 忽略灰色（色调为-1）
//                     h = (h + hueDelta + 360) % 360;
//                     color.setHsv(h, s, v);
//                 }

//                 result.setPixelColor(x, y, color);
//             }
//         }

//         return result;
//     }

//     // 调整饱和度（范围：-50 到 50，0为原始值，负值降低饱和度，正值提高饱和度）
//     static QImage adjustSaturation(const QImage& image, int saturationOffset) {
//         // 限制输入范围在 [-50, 50]
//         saturationOffset = qBound(-50, saturationOffset, 50);

//         // 将 [-50, 50] 映射到 [0.0, 2.0]（0 → 1.0 原始饱和度）
//         // 公式：saturationFactor = 1.0 + (saturationOffset / 50.0)
//         double saturationFactor = 1.0 + (saturationOffset / 50.0);

//         QImage result = image.copy();

//         for (int y = 0; y < result.height(); y++) {
//             QRgb* row = (QRgb*)result.scanLine(y); // 高效像素操作
//             for (int x = 0; x < result.width(); x++) {
//                 QColor color(row[x]);
//                 int h, s, v;
//                 color.getHsv(&h, &s, &v);

//                 // 应用饱和度调整（限制在0-255范围内）
//                 s = qBound(0, (int)(s * saturationFactor), 255);
//                 color.setHsv(h, s, v);

//                 row[x] = color.rgb();
//             }
//         }

//         return result;
//     }
//     // 调整亮度（范围：-100 到 100）
//     static QImage adjustBrightness(const QImage& image, int brightnessDelta) {
//         QImage result = image.copy();

//         for (int y = 0; y < result.height(); y++) {
//             for (int x = 0; x < result.width(); x++) {
//                 QColor color = result.pixelColor(x, y);
//                 int r = qBound(0, color.red() + brightnessDelta, 255);
//                 int g = qBound(0, color.green() + brightnessDelta, 255);
//                 int b = qBound(0, color.blue() + brightnessDelta, 255);
//                 result.setPixelColor(x, y, QColor(r, g, b));
//             }
//         }

//         return result;
//     }

//     // 综合调整（色温、色调、饱和度、亮度）
//     static QImage adjustImage(const QImage& image,
//                               int temperature = 0,
//                               int hueDelta = 0,
//                               int saturationFactor = 1.0,
//                               int brightnessDelta = 0) {
//         QImage result = image.copy();

//         if (temperature != 0)
//             result = adjustTemperature(result, temperature);

//         if (hueDelta != 0)
//             result = adjustHue(result, hueDelta);

//         if (saturationFactor != 0)
//             result = adjustSaturation(result, saturationFactor);

//         if (brightnessDelta != 0)
//             result = adjustBrightness(result, brightnessDelta);

//         return result;
//     }
// };



#include <QImage>
#include <QColor>
#include <algorithm>
#include <tuple>

class ImageColorAdjuster {
public:
    /**
     * 统一色彩调整函数：合并色温、色调、饱和度、亮度调整
     * @param image 输入图像（为空时返回空图像）
     * @param temperature 色温调整（[-50,50]，0禁用；负值偏暖，正值偏冷）
     * @param hueDelta 色调调整（[-180,180]，0禁用）
     * @param saturationOffset 饱和度调整（[-50,50]，0禁用；负值降低，正值提高）
     * @param brightnessDelta 亮度调整（[-100,100]，0禁用；负值降低，正值提高）
     * @return 调整后的图像
     */
    static QImage adjustImage(const QImage& image,
                              int temperature = 0,
                              int hueDelta = 0,
                              int saturationOffset = 0,
                              int brightnessDelta = 0) {
        // 空图像直接返回
        if (image.isNull()) return QImage();

        // 统一图像格式为ARGB32（确保像素操作兼容且高效）
        QImage result = image.convertToFormat(QImage::Format_ARGB32);
        const int width = result.width();
        const int height = result.height();

        // 预计算各项调整所需的参数（仅在启用时计算，减少冗余）
        // 1. 色温调整参数
        bool enableTemp = (temperature != 0);
        double rScale = 1.0, gScale = 1.0, bScale = 1.0;
        if (enableTemp) {
            const int clampedTemp = qBound(-50, temperature, 50);
            const int kelvin = 6500 + clampedTemp * 110;
            std::tie(rScale, gScale, bScale) = calculateTempScales(kelvin);
        }

        // 2. 色调调整参数
        bool enableHue = (hueDelta != 0);
        const int clampedHue = enableHue ? (hueDelta % 360 + 360) % 360 : 0;

        // 3. 饱和度调整参数
        bool enableSaturation = (saturationOffset != 0);
        const double satFactor = enableSaturation
                                     ? (1.0 + qBound(-50, saturationOffset, 50) / 50.0)
                                     : 1.0;

        // 4. 亮度调整参数
        bool enableBrightness = (brightnessDelta != 0);
        const int clampedBrightness = enableBrightness
                                          ? qBound(-100, brightnessDelta, 100)
                                          : 0;

        // 遍历像素，按顺序应用所有启用的调整
        for (int y = 0; y < height; ++y) {
            QRgb* row = reinterpret_cast<QRgb*>(result.scanLine(y));
            for (int x = 0; x < width; ++x) {
                QRgb pixel = row[x];
                int r = qRed(pixel);
                int g = qGreen(pixel);
                int b = qBlue(pixel);
                const int alpha = qAlpha(pixel); // 保留Alpha通道

                // 应用色温调整（RGB缩放）
                if (enableTemp) {
                    r = std::clamp(static_cast<int>(r * rScale), 0, 255);
                    g = std::clamp(static_cast<int>(g * gScale), 0, 255);
                    b = std::clamp(static_cast<int>(b * bScale), 0, 255);
                }

                // 转换为HSV，用于色调和饱和度调整
                QColor color(r, g, b);
                int h, s, v;
                color.getHsv(&h, &s, &v);

                // 应用色调调整
                if (enableHue && h != -1) { // 跳过灰色（h=-1）
                    h = (h + clampedHue) % 360;
                }

                // 应用饱和度调整
                if (enableSaturation) {
                    s = std::clamp(static_cast<int>(s * satFactor), 0, 255);
                }

                // 转换回RGB，准备亮度调整
                color.setHsv(h, s, v);
                r = color.red();
                g = color.green();
                b = color.blue();

                // 应用亮度调整
                if (enableBrightness) {
                    r = std::clamp(r + clampedBrightness, 0, 255);
                    g = std::clamp(g + clampedBrightness, 0, 255);
                    b = std::clamp(b + clampedBrightness, 0, 255);
                }

                // 更新像素（保留原始Alpha）
                row[x] = qRgba(r, g, b, alpha);
            }
        }

        return result;
    }

private:
    // 色温-RGB映射表（按开尔文温度升序）
    struct TempMap {
        int kelvin;
        double r, g, b;
    };
    static const TempMap tempTable[];

    // 计算色温对应的RGB缩放系数（线性插值）
    static std::tuple<double, double, double> calculateTempScales(int targetKelvin);
};



#endif // IMAGECOLORADJUSTER_H
